#ifndef _FileRes_h
#define _FileRes_h

#include "CxxUtils.h"
#include "LangUtils.h"

class DoOpFileRes
{
public: 
	class ds_file : public _DoOperator
	{
	protected: 
		ds_file(const ds_file &);
		ds_file& operator=(const ds_file &);
	public: 
		ds_file() : _DoOperator() {
		}

		virtual void execute(DevilSemantic &semantic);
	};

	class ds_filter : public _DoOperator
	{
	protected: 
		ds_filter(const ds_filter &);
		ds_filter& operator=(const ds_filter &);
	public: 
		ds_filter() : _DoOperator() {
		}

		virtual void execute(DevilSemantic &semantic);
	};

	class ds_closefile : public _DoOperator
	{
	protected: 
		ds_closefile(const ds_closefile &);
		ds_closefile& operator=(const ds_closefile &);
	public: 
		ds_closefile() : _DoOperator() {
		}

		virtual void execute(DevilSemantic &semantic);
	};

	class ds_read : public _DoOperator
	{
	protected: 
		ds_read(const ds_read &);
		ds_read& operator=(const ds_read &);
	public: 
		ds_read() : _DoOperator() {
		}

		virtual void execute(DevilSemantic &semantic);
	};

	class ds_write : public _DoOperator
	{
	protected: 
		ds_write(const ds_write &);
		ds_write& operator=(const ds_write &);
	public: 
		ds_write() : _DoOperator() {
		}

		virtual void execute(DevilSemantic &semantic);
	};

	class ds_readhexstring : public _DoOperator
	{
	protected: 
		ds_readhexstring(const ds_readhexstring &);
		ds_readhexstring& operator=(const ds_readhexstring &);
	public: 
		ds_readhexstring() : _DoOperator() {
		}

		virtual void execute(DevilSemantic &semantic);
	};

	class ds_writehexstring : public _DoOperator
	{
	protected: 
		ds_writehexstring(const ds_writehexstring &);
		ds_writehexstring& operator=(const ds_writehexstring &);
	public: 
		ds_writehexstring() : _DoOperator() {
		}

		virtual void execute(DevilSemantic &semantic);
	};

	class ds_readstring : public _DoOperator
	{
	protected: 
		ds_readstring(const ds_readstring &);
		ds_readstring& operator=(const ds_readstring &);
	public: 
		ds_readstring() : _DoOperator() {
		}

		virtual void execute(DevilSemantic &semantic);
	};

	class ds_writestring : public _DoOperator
	{
	protected: 
		ds_writestring(const ds_writestring &);
		ds_writestring& operator=(const ds_writestring &);
	public: 
		ds_writestring() : _DoOperator() {
		}

		virtual void execute(DevilSemantic &semantic);
	};

	class ds_readline : public _DoOperator
	{
	protected: 
		ds_readline(const ds_readline &);
		ds_readline& operator=(const ds_readline &);
	public: 
		ds_readline() : _DoOperator() {
		}

		virtual void execute(DevilSemantic &semantic);
	};

	class ds_token : public _DoOperator
	{
	protected: 
		ds_token(const ds_token &);
		ds_token& operator=(const ds_token &);
	public: 
		ds_token() : _DoOperator() {
		}

		virtual void execute(DevilSemantic &semantic);
	};

	class ds_bytesavailable : public _DoOperator
	{
	protected: 
		ds_bytesavailable(const ds_bytesavailable &);
		ds_bytesavailable& operator=(const ds_bytesavailable &);
	public: 
		ds_bytesavailable() : _DoOperator() {
		}

		virtual void execute(DevilSemantic &semantic);
	};

	class ds_flush : public _DoOperator
	{
	protected: 
		ds_flush(const ds_flush &);
		ds_flush& operator=(const ds_flush &);
	public: 
		ds_flush() : _DoOperator() {
		}

		virtual void execute(DevilSemantic &semantic);
	};

	class ds_flushfile : public _DoOperator
	{
	protected: 
		ds_flushfile(const ds_flushfile &);
		ds_flushfile& operator=(const ds_flushfile &);
	public: 
		ds_flushfile() : _DoOperator() {
		}

		virtual void execute(DevilSemantic &semantic);
	};

	class ds_resetfile : public _DoOperator
	{
	protected: 
		ds_resetfile(const ds_resetfile &);
		ds_resetfile& operator=(const ds_resetfile &);
	public: 
		ds_resetfile() : _DoOperator() {
		}

		virtual void execute(DevilSemantic &semantic);
	};

	class ds_status : public _DoOperator
	{
	protected: 
		ds_status(const ds_status &);
		ds_status& operator=(const ds_status &);
	public: 
		ds_status() : _DoOperator() {
		}

		virtual void execute(DevilSemantic &semantic);
	};

	class ds_run : public _DoOperator
	{
	protected: 
		ds_run(const ds_run &);
		ds_run& operator=(const ds_run &);
	public: 
		ds_run() : _DoOperator() {
		}

		virtual void execute(DevilSemantic &semantic);
	};

	class ds_currentfile : public _DoOperator
	{
	protected: 
		ds_currentfile(const ds_currentfile &);
		ds_currentfile& operator=(const ds_currentfile &);
	public: 
		ds_currentfile() : _DoOperator() {
		}

		virtual void execute(DevilSemantic &semantic);
	};

	class ds_deletefile : public _DoOperator
	{
	protected: 
		ds_deletefile(const ds_deletefile &);
		ds_deletefile& operator=(const ds_deletefile &);
	public: 
		ds_deletefile() : _DoOperator() {
		}

		virtual void execute(DevilSemantic &semantic);
	};

	class ds_renamefile : public _DoOperator
	{
	protected: 
		ds_renamefile(const ds_renamefile &);
		ds_renamefile& operator=(const ds_renamefile &);
	public: 
		ds_renamefile() : _DoOperator() {
		}

		virtual void execute(DevilSemantic &semantic);
	};

	class ds_filenameforall : public _DoOperator
	{
	protected: 
		ds_filenameforall(const ds_filenameforall &);
		ds_filenameforall& operator=(const ds_filenameforall &);
	public: 
		ds_filenameforall() : _DoOperator() {
		}

		virtual void execute(DevilSemantic &semantic);
	};

	class ds_setfileposition : public _DoOperator
	{
	protected: 
		ds_setfileposition(const ds_setfileposition &);
		ds_setfileposition& operator=(const ds_setfileposition &);
	public: 
		ds_setfileposition() : _DoOperator() {
		}

		virtual void execute(DevilSemantic &semantic);
	};

	class ds_fileposition : public _DoOperator
	{
	protected: 
		ds_fileposition(const ds_fileposition &);
		ds_fileposition& operator=(const ds_fileposition &);
	public: 
		ds_fileposition() : _DoOperator() {
		}

		virtual void execute(DevilSemantic &semantic);
	};

	class ds_print : public _DoOperator
	{
	protected: 
		ds_print(const ds_print &);
		ds_print& operator=(const ds_print &);
	public: 
		ds_print() : _DoOperator() {
		}

		virtual void execute(DevilSemantic &semantic);
	};

	class ds_writestdout : public _DoOperator
	{
	protected: 
		ds_writestdout(const ds_writestdout &);
		ds_writestdout& operator=(const ds_writestdout &);
	public: 
		ds_writestdout() : _DoOperator() {
		}

		virtual void execute(DevilSemantic &semantic);
	};

	class ds_writestdout2 : public _DoOperator
	{
	protected: 
		ds_writestdout2(const ds_writestdout2 &);
		ds_writestdout2& operator=(const ds_writestdout2 &);
	public: 
		ds_writestdout2() : _DoOperator() {
		}

		virtual void execute(DevilSemantic &semantic);
	};

	class ds_stack : public _DoOperator
	{
	protected: 
		ds_stack(const ds_stack &);
		ds_stack& operator=(const ds_stack &);
	public: 
		ds_stack() : _DoOperator() {
		}

		virtual void execute(DevilSemantic &semantic);
	};

	class ds_pstack : public _DoOperator
	{
	protected: 
		ds_pstack(const ds_pstack &);
		ds_pstack& operator=(const ds_pstack &);
	public: 
		ds_pstack() : _DoOperator() {
		}

		virtual void execute(DevilSemantic &semantic);
	};

	class ds_printobject : public _DoOperator
	{
	protected: 
		ds_printobject(const ds_printobject &);
		ds_printobject& operator=(const ds_printobject &);
	public: 
		ds_printobject() : _DoOperator() {
		}

		virtual void execute(DevilSemantic &semantic);
	};

	class ds_writeobject : public _DoOperator
	{
	protected: 
		ds_writeobject(const ds_writeobject &);
		ds_writeobject& operator=(const ds_writeobject &);
	public: 
		ds_writeobject() : _DoOperator() {
		}

		virtual void execute(DevilSemantic &semantic);
	};

	class ds_setobjectformat : public _DoOperator
	{
	protected: 
		ds_setobjectformat(const ds_setobjectformat &);
		ds_setobjectformat& operator=(const ds_setobjectformat &);
	public: 
		ds_setobjectformat() : _DoOperator() {
		}

		virtual void execute(DevilSemantic &semantic);
	};

	class ds_currentobjectformat : public _DoOperator
	{
	protected: 
		ds_currentobjectformat(const ds_currentobjectformat &);
		ds_currentobjectformat& operator=(const ds_currentobjectformat &);
	public: 
		ds_currentobjectformat() : _DoOperator() {
		}

		virtual void execute(DevilSemantic &semantic);
	};

	static void push(_DoDictionaryMultimap& dict) {
		dict.put(CRefPtr< _DoObject >(new DoName("file")), CRefPtr< _DoObject >(new ds_file()));
		dict.put(CRefPtr< _DoObject >(new DoName("filter")), CRefPtr< _DoObject >(new ds_filter()));
		dict.put(CRefPtr< _DoObject >(new DoName("closefile")), CRefPtr< _DoObject >(new ds_closefile()));
		dict.put(CRefPtr< _DoObject >(new DoName("read")), CRefPtr< _DoObject >(new ds_read()));
		dict.put(CRefPtr< _DoObject >(new DoName("write")), CRefPtr< _DoObject >(new ds_write()));
		dict.put(CRefPtr< _DoObject >(new DoName("readhexstring")), CRefPtr< _DoObject >(new ds_readhexstring()));
		dict.put(CRefPtr< _DoObject >(new DoName("writehexstring")), CRefPtr< _DoObject >(new ds_writehexstring()));
		dict.put(CRefPtr< _DoObject >(new DoName("readstring")), CRefPtr< _DoObject >(new ds_readstring()));
		dict.put(CRefPtr< _DoObject >(new DoName("writestring")), CRefPtr< _DoObject >(new ds_writestring()));
		dict.put(CRefPtr< _DoObject >(new DoName("readline")), CRefPtr< _DoObject >(new ds_readline()));
		dict.put(CRefPtr< _DoObject >(new DoName("token")), CRefPtr< _DoObject >(new ds_token()));
		dict.put(CRefPtr< _DoObject >(new DoName("bytesavailable")), CRefPtr< _DoObject >(new ds_bytesavailable()));
		dict.put(CRefPtr< _DoObject >(new DoName("flush")), CRefPtr< _DoObject >(new ds_flush()));
		dict.put(CRefPtr< _DoObject >(new DoName("flushfile")), CRefPtr< _DoObject >(new ds_flushfile()));
		dict.put(CRefPtr< _DoObject >(new DoName("resetfile")), CRefPtr< _DoObject >(new ds_resetfile()));
		dict.put(CRefPtr< _DoObject >(new DoName("status")), CRefPtr< _DoObject >(new ds_status()));
		dict.put(CRefPtr< _DoObject >(new DoName("run")), CRefPtr< _DoObject >(new ds_run()));
		dict.put(CRefPtr< _DoObject >(new DoName("currentfile")), CRefPtr< _DoObject >(new ds_currentfile()));
		dict.put(CRefPtr< _DoObject >(new DoName("deletefile")), CRefPtr< _DoObject >(new ds_deletefile()));
		dict.put(CRefPtr< _DoObject >(new DoName("renamefile")), CRefPtr< _DoObject >(new ds_renamefile()));
		dict.put(CRefPtr< _DoObject >(new DoName("filenameforall")), CRefPtr< _DoObject >(new ds_filenameforall()));
		dict.put(CRefPtr< _DoObject >(new DoName("setfileposition")), CRefPtr< _DoObject >(new ds_setfileposition()));
		dict.put(CRefPtr< _DoObject >(new DoName("fileposition")), CRefPtr< _DoObject >(new ds_fileposition()));
		dict.put(CRefPtr< _DoObject >(new DoName("print")), CRefPtr< _DoObject >(new ds_print()));
		dict.put(CRefPtr< _DoObject >(new DoName("writestdout")), CRefPtr< _DoObject >(new ds_writestdout()));
		dict.put(CRefPtr< _DoObject >(new DoName("writestdout2")), CRefPtr< _DoObject >(new ds_writestdout2()));
		dict.put(CRefPtr< _DoObject >(new DoName("stack")), CRefPtr< _DoObject >(new ds_stack()));
		dict.put(CRefPtr< _DoObject >(new DoName("pstack")), CRefPtr< _DoObject >(new ds_pstack()));
		dict.put(CRefPtr< _DoObject >(new DoName("printobject")), CRefPtr< _DoObject >(new ds_printobject()));
		dict.put(CRefPtr< _DoObject >(new DoName("writeobject")), CRefPtr< _DoObject >(new ds_writeobject()));
		dict.put(CRefPtr< _DoObject >(new DoName("setobjectformat")), CRefPtr< _DoObject >(new ds_setobjectformat()));
		dict.put(CRefPtr< _DoObject >(new DoName("currentobjectformat")), CRefPtr< _DoObject >(new ds_currentobjectformat()));
	}
};

#endif
